home *** CD-ROM | disk | FTP | other *** search
/ Hardcore Visual Basic 5.0 (2nd Edition) / Hardcore Visual Basic 5.0 - Second Edition (1997)(Microsoft Press).iso / Source / WinTlb / OBJBASE.IDL < prev    next >
Text File  |  1997-04-22  |  18KB  |  500 lines
  1. //+---------------------------------------------------------------------------
  2. //
  3. //  Microsoft Windows
  4. //  Copyright (C) Microsoft Corporation, 1992 - 1996.
  5. //
  6. //  File:       objbase.h
  7. //
  8. //  Contents:   Component object model defintions.
  9. //
  10. //----------------------------------------------------------------------------
  11.  
  12.  
  13. #define WINOLEAPI        HRESULT WINAPI
  14. #define WINOLEAPI_(type) type WINAPI
  15.  
  16. //define LISet32(li, v) ((li).HighPart = (v) < 0 ? -1 : 0, (li).LowPart = (v))
  17.  
  18. //define ULISet32(li, v) ((li).HighPart = 0, (li).LowPart = (v))
  19.  
  20.  
  21.  
  22.  
  23.  
  24.     //define CLSCTX_INPROC           (CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER)
  25.  
  26. // With DCOM, CLSCTX_REMOTE_SERVER can be included
  27. // #if _WIN32_WINNT >= 0x0400
  28.     //define CLSCTX_ALL              (CLSCTX_INPROC_SERVER| CLSCTX_INPROC_HANDLER| CLSCTX_LOCAL_SERVER| CLSCTX_REMOTE_SERVER)
  29.  
  30.     //define CLSCTX_SERVER           (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER|CLSCTX_REMOTE_SERVER)
  31. // #else
  32. //     const DWORD CLSCTX_ALL              (CLSCTX_INPROC_SERVER| \
  33. //                                  CLSCTX_INPROC_HANDLER| \
  34. //                                  CLSCTX_LOCAL_SERVER )
  35. //
  36. //     const DWORD CLSCTX_SERVER           (CLSCTX_INPROC_SERVER|CLSCTX_LOCAL_SERVER)
  37. // #endif
  38.  
  39.  
  40. // class registration flags; passed to CoRegisterClassObject
  41. typedef enum REGCLS {
  42.     REGCLS_SINGLEUSE = 0,       // class object only generates one instance
  43.     REGCLS_MULTIPLEUSE = 1,     // same class object genereates multiple inst.
  44.                                 // and local automatically goes into inproc tbl.
  45.     REGCLS_MULTI_SEPARATE = 2   // multiple use, but separate control over each
  46.                                 // context.
  47. } REGCLS;
  48.  
  49. // here is where we pull in the MIDL generated headers for the interfaces
  50.  
  51. //typedef interface    IRpcStubBuffer     IRpcStubBuffer;
  52. //typedef interface    IRpcChannelBuffer  IRpcChannelBuffer;
  53.  
  54. // COM initialization flags; passed to CoInitialize.
  55. typedef enum COINIT {
  56.   COINIT_MULTITHREADED      = 0x0,      // OLE calls objects on any thread.
  57.   COINIT_APARTMENTTHREADED  = 0x2,      // Apartment model
  58.   COINIT_DISABLE_OLE1DDE    = 0x4,      // Don't use DDE for Ole1 support.
  59.   COINIT_SPEED_OVER_MEMORY  = 0x8,      // Trade memory for speed.
  60. } COINIT;
  61.  
  62. typedef struct COSERVERINFO {
  63.     DWORD       dwSize;
  64.     OLECHAR *   pszName;  // machine name
  65. } COSERVERINFO;
  66.  
  67.  
  68. //typedef HRESULT (STDAPICALLTYPE * LPFNGETCLASSOBJECT) (REFCLSID, REFIID, LPVOID *);
  69. typedef long LPFNGETCLASSOBJECT;
  70.  
  71. //typedef HRESULT (STDAPICALLTYPE * LPFNCANUNLOADNOW)(void);
  72. typedef long LPFNCANUNLOADNOW;
  73.  
  74.  
  75. //
  76. // Common typedefs for paramaters used in Storage API's, gleamed from storage.h
  77. // Also contains Storage error codes, which should be moved into the storage
  78. // idl files.
  79. //
  80.  
  81.  
  82. [
  83. #ifdef UNICODE
  84. uuid(64675066-3A82-101B-8181-00AA003743D3),
  85. #else
  86. uuid(64674066-3A82-101B-8181-00AA003743D3),
  87. #endif
  88. helpstring("Object Base Function Entries and Constants"),
  89. dllname("OLE32.DLL")
  90. ]
  91. module ObjBase {
  92.  
  93.     // interface marshaling definitions
  94.     const DWORD MARSHALINTERFACE_MIN    = 500; // minimum number of bytes for interface marshl
  95.  
  96.     const DWORD CWCSTORAGENAME = 32;
  97.  
  98.     // Storage instantiation modes
  99.     const DWORD STGM_DIRECT             = 0x00000000;
  100.     const DWORD STGM_TRANSACTED         = 0x00010000;
  101.     const DWORD STGM_SIMPLE             = 0x08000000;
  102.  
  103.     const DWORD STGM_READ               = 0x00000000;
  104.     const DWORD STGM_WRITE              = 0x00000001;
  105.     const DWORD STGM_READWRITE          = 0x00000002;
  106.  
  107.     const DWORD STGM_SHARE_DENY_NONE    = 0x00000040;
  108.     const DWORD STGM_SHARE_DENY_READ    = 0x00000030;
  109.     const DWORD STGM_SHARE_DENY_WRITE   = 0x00000020;
  110.     const DWORD STGM_SHARE_EXCLUSIVE    = 0x00000010;
  111.  
  112.     const DWORD STGM_PRIORITY           = 0x00040000;
  113.     const DWORD STGM_DELETEONRELEASE    = 0x04000000;
  114.     // #if (WINVER >= 400)
  115.     const DWORD STGM_NOSCRATCH          = 0x00100000;
  116.     // #endif // WINVER
  117.  
  118.     const DWORD STGM_CREATE             = 0x00001000;
  119.     const DWORD STGM_CONVERT            = 0x00020000;
  120.     const DWORD STGM_FAILIFTHERE        = 0x00000000;
  121.  
  122.     const DWORD STGM_NOSNAPSHOT         = 0x00200000;
  123.  
  124.     //  flags for internet asyncronous and layout docfile
  125.     const DWORD ASYNC_MODE_COMPATIBILITY    = 0x00000001;
  126.     const DWORD ASYNC_MODE_DEFAULT          = 0x00000000;
  127.  
  128.     const DWORD STGTY_REPEAT                = 0x00000100;
  129.     const DWORD STG_TOEND                   = 0xFFFFFFFF;
  130.  
  131.     const DWORD STG_LAYOUT_SEQUENTIAL       = 0x00000000;
  132.     const DWORD STG_LAYOUT_INTERLEAVED      = 0x00000001;
  133.  
  134.     #if 0
  135.  
  136.     //***** STD Object API Prototypes *****
  137.  
  138.     WINOLEAPI_(DWORD) CoBuildVersion( VOID );
  139.  
  140.     // init/uninit
  141.  
  142.     WINOLEAPI  CoInitialize(LPVOID pvReserved);
  143.     WINOLEAPI  CoInitializeEx(LPVOID pvReserved, DWORD dwCoInit);
  144.     WINOLEAPI_(void)  CoUninitialize(void);
  145.     WINOLEAPI  CoGetMalloc(DWORD dwMemContext, LPMALLOC FAR* ppMalloc);
  146.     WINOLEAPI_(DWORD) CoGetCurrentProcess(void);
  147.     WINOLEAPI  CoRegisterMallocSpy(LPMALLOCSPY pMallocSpy);
  148.     WINOLEAPI  CoRevokeMallocSpy(void);
  149.     WINOLEAPI  CoCreateStandardMalloc(DWORD memctx, IMalloc FAR* FAR* ppMalloc);
  150.  
  151.     #if DBG == 1
  152.     WINOLEAPI_(ULONG) DebugCoGetRpcFault( void );
  153.     WINOLEAPI_(void) DebugCoSetRpcFault( ULONG );
  154.     #endif
  155.  
  156.     // register/revoke/get class objects
  157.  
  158.     WINOLEAPI  CoGetClassObject(REFCLSID rclsid, DWORD dwClsContext, LPVOID pvReserved,
  159.                         REFIID riid, LPVOID FAR* ppv);
  160.     WINOLEAPI  CoRegisterClassObject(REFCLSID rclsid, LPUNKNOWN pUnk,
  161.                         DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister);
  162.     WINOLEAPI  CoRevokeClassObject(DWORD dwRegister);
  163.  
  164.  
  165.     // marshaling interface pointers
  166.  
  167.     WINOLEAPI CoGetMarshalSizeMax(ULONG *pulSize, REFIID riid, LPUNKNOWN pUnk,
  168.                         DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
  169.     WINOLEAPI CoMarshalInterface(LPSTREAM pStm, REFIID riid, LPUNKNOWN pUnk,
  170.                         DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags);
  171.     WINOLEAPI CoUnmarshalInterface(LPSTREAM pStm, REFIID riid, LPVOID FAR* ppv);
  172.     WINOLEAPI CoMarshalHresult(LPSTREAM pstm, HRESULT hresult);
  173.     WINOLEAPI CoUnmarshalHresult(LPSTREAM pstm, HRESULT FAR * phresult);
  174.     WINOLEAPI CoReleaseMarshalData(LPSTREAM pStm);
  175.     WINOLEAPI CoDisconnectObject(LPUNKNOWN pUnk, DWORD dwReserved);
  176.     WINOLEAPI CoLockObjectExternal(LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases);
  177.     WINOLEAPI CoGetStandardMarshal(REFIID riid, LPUNKNOWN pUnk,
  178.                         DWORD dwDestContext, LPVOID pvDestContext, DWORD mshlflags,
  179.                         LPMARSHAL FAR* ppMarshal);
  180.  
  181.     WINOLEAPI_(BOOL) CoIsHandlerConnected(LPUNKNOWN pUnk);
  182.     WINOLEAPI_(BOOL) CoHasStrongExternalConnections(LPUNKNOWN pUnk);
  183.  
  184.     // Apartment model inter-thread interface passing helpers
  185.     WINOLEAPI CoMarshalInterThreadInterfaceInStream(REFIID riid, LPUNKNOWN pUnk,
  186.                         LPSTREAM *ppStm);
  187.  
  188.     WINOLEAPI CoGetInterfaceAndReleaseStream(LPSTREAM pStm, REFIID iid,
  189.                         LPVOID FAR* ppv);
  190.  
  191.     WINOLEAPI CoCreateFreeThreadedMarshaler(LPUNKNOWN  punkOuter,
  192.                         LPUNKNOWN *ppunkMarshal);
  193.  
  194.     // dll loading helpers; keeps track of ref counts and unloads all on exit
  195.  
  196.     WINOLEAPI_(HINSTANCE) CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree);
  197.     WINOLEAPI_(void) CoFreeLibrary(HINSTANCE hInst);
  198.     WINOLEAPI_(void) CoFreeAllLibraries(void);
  199.     WINOLEAPI_(void) CoFreeUnusedLibraries(void);
  200.  
  201.  
  202.     // Call Security.
  203.  
  204.     WINOLEAPI CoInitializeSecurity(
  205.                         PSECURITY_DESCRIPTOR         pSecDesc,
  206.                         LONG                         cbAuthSvc,
  207.                         SOLE_AUTHENTICATION_SERVICE *asAuthSvc,
  208.                         WCHAR                       *pClientPrincName,
  209.                         DWORD                        dwAuthnLevel,
  210.                         DWORD                        dwImpLevel,
  211.                         RPC_AUTH_IDENTITY_HANDLE     pAuthInfo,
  212.                         DWORD                        dwCapabilities,
  213.                         void                        *pReserved );
  214.     WINOLEAPI CoQueryAuthenticationServices( DWORD *pcbAuthSvc,
  215.                                           SOLE_AUTHENTICATION_SERVICE **asAuthSvc );
  216.     WINOLEAPI CoGetCallContext( REFIID riid, void **ppInterface );
  217.     WINOLEAPI CoSwitchCallContext( IUnknown *pNewObject, IUnknown **ppOldObject );
  218.     WINOLEAPI CoQueryProxyBlanket(
  219.         IUnknown                  *pProxy,
  220.         DWORD                     *pwAuthnSvc,
  221.         DWORD                     *pAuthzSvc,
  222.         OLECHAR                  **pServerPrincName,
  223.         DWORD                     *pAuthnLevel,
  224.         DWORD                     *pImpLevel,
  225.         RPC_AUTH_IDENTITY_HANDLE  *pAuthInfo,
  226.         DWORD                     *pCapabilites );
  227.     WINOLEAPI CoSetProxyBlanket(
  228.         IUnknown                 *pProxy,
  229.         DWORD                     dwAuthnSvc,
  230.         DWORD                     dwAuthzSvc,
  231.         OLECHAR                  *pServerPrincName,
  232.         DWORD                     dwAuthnLevel,
  233.         DWORD                     dwImpLevel,
  234.         RPC_AUTH_IDENTITY_HANDLE  pAuthInfo,
  235.         DWORD                     dwCapabilities );
  236.     WINOLEAPI CoCopyProxy(
  237.         IUnknown    *pProxy,
  238.         IUnknown   **ppCopy );
  239.     WINOLEAPI CoQueryClientBlanket(
  240.         DWORD             *pAuthnSvc,
  241.         DWORD             *pAuthzSvc,
  242.         OLECHAR          **pServerPrincName,
  243.         DWORD             *pAuthnLevel,
  244.         DWORD             *pImpLevel,
  245.         RPC_AUTHZ_HANDLE  *pPrivs,
  246.         DWORD             *pCapabilities );
  247.     WINOLEAPI CoImpersonateClient();
  248.     WINOLEAPI CoRevertToSelf();
  249.  
  250.         const DWORD COM_RIGHTS_EXECUTE 1
  251.  
  252.  
  253.     // helper for creating instances
  254.  
  255.     WINOLEAPI CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
  256.                         DWORD dwClsContext, REFIID riid, LPVOID FAR* ppv);
  257.  
  258.  
  259.     WINOLEAPI CoGetPersistentInstance(
  260.         REFIID riid,
  261.         DWORD dwCtrl,
  262.         DWORD grfMode,
  263.         OLECHAR *pwszName,
  264.         struct IStorage *pstg,
  265.         REFCLSID rclsidOle1,
  266.         BOOL * pfOle1Loaded,
  267.         void **ppvUnk);
  268.  
  269.  
  270.     WINOLEAPI CoGetInstanceFromFile(
  271.         COSERVERINFO *              pServerInfo,
  272.         CLSID       *               pClsid,
  273.         IUnknown    *               punkOuter, // only relevant locally
  274.         DWORD                       dwClsCtx,
  275.         DWORD                       grfMode,
  276.         OLECHAR *                   pwszName,
  277.         DWORD                       dwCount,
  278.         MULTI_QI        *           pResults );
  279.  
  280.     WINOLEAPI CoGetInstanceFromIStorage(
  281.         COSERVERINFO *              pServerInfo,
  282.         CLSID       *               pClsid,
  283.         IUnknown    *               punkOuter, // only relevant locally
  284.         DWORD                       dwClsCtx,
  285.         struct IStorage *           pstg,
  286.         DWORD                       dwCount,
  287.         MULTI_QI        *           pResults );
  288.  
  289.     WINOLEAPI CoCreateInstanceEx(
  290.         REFCLSID                    Clsid,
  291.         IUnknown    *               punkOuter, // only relevant locally
  292.         DWORD                       dwClsCtx,
  293.         COSERVERINFO *              pServerInfo,
  294.         DWORD                       dwCount,
  295.         MULTI_QI        *           pResults );
  296.  
  297.     // other helpers
  298.     #endif
  299.  
  300.     [
  301.     usesgetlasterror,
  302.     entry("StringFromCLSID"),
  303.     helpstring(""),
  304.     ]
  305.     WINOLEAPI StringFromCLSID(REFCLSID rclsid, 
  306.                               LPOLESTR * lplpsz);
  307.  
  308.     [
  309.     usesgetlasterror,
  310.     entry("CLSIDFromString"),
  311.     helpstring(""),
  312.     ]
  313.     WINOLEAPI CLSIDFromString(LPOLESTR lpsz, LPCLSID pclsid);
  314.  
  315.     [
  316.     usesgetlasterror,
  317.     entry("StringFromIID"),
  318.     helpstring(""),
  319.     ]
  320.     WINOLEAPI StringFromIID(REFIID rclsid, 
  321.                             LPOLESTR * lplpsz);
  322.  
  323.     [
  324.     usesgetlasterror,
  325.     entry("IIDFromString"),
  326.     helpstring(""),
  327.     ]
  328.     WINOLEAPI IIDFromString(LPOLESTR lpsz, 
  329.                             LPIID lpiid);
  330.  
  331.     /*
  332.     [
  333.     usesgetlasterror,
  334.     entry("CoIsOle1Class"),
  335.     helpstring(""),
  336.     ]
  337.     WINOLEAPI_(BOOL) CoIsOle1Class(REFCLSID rclsid);
  338.     */
  339.  
  340.     [
  341.     usesgetlasterror,
  342.     entry("ProgIDFromCLSID"),
  343.     helpstring(""),
  344.     ]
  345.     WINOLEAPI ProgIDFromCLSID(REFCLSID clsid, 
  346.                               LPOLESTR * lplpszProgID);
  347.  
  348.     [
  349.     usesgetlasterror,
  350.     entry("CLSIDFromProgID"),
  351.     helpstring(""),
  352.     ]
  353.     WINOLEAPI CLSIDFromProgID(LPCOLESTR lpszProgID, 
  354.                               LPCLSID lpclsid);
  355.  
  356.     [
  357.     usesgetlasterror,
  358.     entry("StringFromGUID2"),
  359.     helpstring(""),
  360.     ]
  361.     WINOLEAPI_(int) StringFromGUID2(REFGUID rguid, 
  362.                                     LPOLESTR lpsz, int cbMax);
  363.  
  364.     [
  365.     usesgetlasterror,
  366.     entry("CoCreateGuid"),
  367.     helpstring(""),
  368.     ]
  369.     WINOLEAPI CoCreateGuid(GUID *pguid);
  370.  
  371.     #if 0
  372.     WINOLEAPI_(BOOL) CoFileTimeToDosDateTime(
  373.                      LPFILETIME lpFileTime, LPWORD lpDosDate, LPWORD lpDosTime);
  374.     WINOLEAPI_(BOOL) CoDosDateTimeToFileTime(
  375.                            WORD nDosDate, WORD nDosTime, LPFILETIME lpFileTime);
  376.     WINOLEAPI  CoFileTimeNow( LPFILETIME lpFileTime );
  377.  
  378.  
  379.     WINOLEAPI CoRegisterMessageFilter( LPMESSAGEFILTER lpMessageFilter,
  380.                                     LPMESSAGEFILTER FAR* lplpMessageFilter );
  381.  
  382.     WINOLEAPI CoRegisterChannelHook( REFGUID ExtensionUuid, IChannelHook *pChannelHook );
  383.  
  384.  
  385.     // TreatAs APIS
  386.  
  387.     WINOLEAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID pClsidNew);
  388.     WINOLEAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew);
  389.  
  390.  
  391.     // the server dlls must define their DllGetClassObject and DllCanUnloadNow
  392.      * to match these; the typedefs are located here to ensure all are changed at
  393.      * the same time.
  394.  
  395.  
  396.     STDAPI  DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID FAR* ppv);
  397.  
  398.     STDAPI  DllCanUnloadNow(void);
  399.  
  400.  
  401.     //***** Default Memory Allocation *****
  402.     WINOLEAPI_(LPVOID) CoTaskMemAlloc(ULONG cb);
  403.     WINOLEAPI_(LPVOID) CoTaskMemRealloc(LPVOID pv, ULONG cb);
  404.     WINOLEAPI_(void)   CoTaskMemFree(LPVOID pv);
  405.  
  406.     //***** DV APIs *******
  407.  
  408.  
  409.     WINOLEAPI CreateDataAdviseHolder(LPDATAADVISEHOLDER FAR* ppDAHolder);
  410.  
  411.     WINOLEAPI CreateDataCache(LPUNKNOWN pUnkOuter, REFCLSID rclsid,
  412.                                             REFIID iid, LPVOID FAR* ppv);
  413.  
  414.  
  415.  
  416.  
  417.     //***** Storage API Prototypes ****
  418.  
  419.  
  420.     WINOLEAPI StgCreateDocfile(const OLECHAR FAR* pwcsName,
  421.                 DWORD grfMode,
  422.                 DWORD reserved,
  423.                 IStorage FAR * FAR *ppstgOpen);
  424.  
  425.     WINOLEAPI StgCreateDocfileOnILockBytes(ILockBytes FAR *plkbyt,
  426.                         DWORD grfMode,
  427.                         DWORD reserved,
  428.                         IStorage FAR * FAR *ppstgOpen);
  429.  
  430.     WINOLEAPI StgOpenStorage(const OLECHAR FAR* pwcsName,
  431.                   IStorage FAR *pstgPriority,
  432.                   DWORD grfMode,
  433.                   SNB snbExclude,
  434.                   DWORD reserved,
  435.                   IStorage FAR * FAR *ppstgOpen);
  436.     WINOLEAPI StgOpenStorageOnILockBytes(ILockBytes FAR *plkbyt,
  437.                       IStorage FAR *pstgPriority,
  438.                       DWORD grfMode,
  439.                       SNB snbExclude,
  440.                       DWORD reserved,
  441.                       IStorage FAR * FAR *ppstgOpen);
  442.  
  443.     WINOLEAPI StgIsStorageFile(const OLECHAR FAR* pwcsName);
  444.     WINOLEAPI StgIsStorageILockBytes(ILockBytes FAR* plkbyt);
  445.  
  446.     WINOLEAPI StgSetTimes(OLECHAR lpszName,
  447.                        LPFILETIME pctime,
  448.                        LPFILETIME patime,
  449.                        LPFILETIME pmtime);
  450.  
  451.     WINOLEAPI StgOpenAsyncDocfileOnIFillLockBytes( IFillLockBytes *pflb,
  452.                  DWORD grfMode,
  453.                  DWORD asyncFlags,
  454.                  IStorage **ppstgOpen);
  455.  
  456.     WINOLEAPI StgGetIFillLockBytesOnILockBytes( ILockBytes *pilb,
  457.                  IFillLockBytes **ppflb);
  458.  
  459.     WINOLEAPI StgGetIFillLockBytesOnFile(OLECHAR const *pwcsName,
  460.                  IFillLockBytes **ppflb);
  461.  
  462.  
  463.     WINOLEAPI StgOpenLayoutDocfile(OLECHAR const *pwcsDfName,
  464.                  DWORD grfMode,
  465.                  DWORD reserved,
  466.                  IStorage **ppstgOpen);
  467.  
  468.  
  469.  
  470.     //
  471.     //  Moniker APIs
  472.     //
  473.  
  474.     WINOLEAPI  BindMoniker(LPMONIKER pmk, DWORD grfOpt, REFIID iidResult, LPVOID FAR* ppvResult);
  475.     WINOLEAPI  CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, void **ppv);
  476.     WINOLEAPI  MkParseDisplayName(LPBC pbc, LPCOLESTR szUserName,
  477.                     ULONG FAR * pchEaten, LPMONIKER FAR * ppmk);
  478.     WINOLEAPI  MonikerRelativePathTo(LPMONIKER pmkSrc, LPMONIKER pmkDest, LPMONIKER
  479.                     FAR* ppmkRelPath, BOOL dwReserved);
  480.     WINOLEAPI  MonikerCommonPrefixWith(LPMONIKER pmkThis, LPMONIKER pmkOther,
  481.                     LPMONIKER FAR* ppmkCommon);
  482.     WINOLEAPI  CreateBindCtx(DWORD reserved, LPBC FAR* ppbc);
  483.     WINOLEAPI  CreateGenericComposite(LPMONIKER pmkFirst, LPMONIKER pmkRest,
  484.         LPMONIKER FAR* ppmkComposite);
  485.     WINOLEAPI  GetClassFile (LPCOLESTR szFilename, CLSID FAR* pclsid);
  486.  
  487.     WINOLEAPI  CreateClassMoniker(REFCLSID rclsid, LPMONIKER FAR* ppmk);
  488.  
  489.     WINOLEAPI  CreateFileMoniker(LPCOLESTR lpszPathName, LPMONIKER FAR* ppmk);
  490.  
  491.     WINOLEAPI  CreateItemMoniker(LPCOLESTR lpszDelim, LPCOLESTR lpszItem,
  492.         LPMONIKER FAR* ppmk);
  493.     WINOLEAPI  CreateAntiMoniker(LPMONIKER FAR* ppmk);
  494.     WINOLEAPI  CreatePointerMoniker(LPUNKNOWN punk, LPMONIKER FAR* ppmk);
  495.  
  496.     WINOLEAPI  GetRunningObjectTable( DWORD reserved, LPRUNNINGOBJECTTABLE FAR* pprot);
  497.  
  498.     #endif
  499. };
  500.